home *** CD-ROM | disk | FTP | other *** search
/ Inter.Net 55-1 / Inter.Net 55-1.iso / CBuilder / Setup / BCB / data.z / valarray.cc < prev    next >
Encoding:
C/C++ Source or Header  |  1998-02-09  |  77.6 KB  |  2,930 lines
  1. #ifndef __VALARRAY_CC
  2. #define __VALARRAY_CC
  3. #pragma option push -b -a4 -Vx- -Ve- -w-inl -w-aus -w-sig
  4.  
  5. /***************************************************************************
  6.  *
  7.  * valaray.cc - Declarations for the Standard Library valarray
  8.  *
  9.  * $Id: valarray.cc,v 1.15 1996/09/26 01:12:57 philippe Exp $
  10.  *
  11.  ***************************************************************************
  12.  *
  13.  * (c) Copyright 1994, 1995 Rogue Wave Software, Inc.
  14.  * ALL RIGHTS RESERVED *
  15.  * The software and information contained herein are proprietary to, and
  16.  * comprise valuable trade secrets of, Rogue Wave Software, Inc., which
  17.  * intends to preserve as trade secrets such software and information.
  18.  * This software is furnished pursuant to a written license agreement and
  19.  * may be used, copied, transmitted, and stored only in accordance with
  20.  * the terms of such license and with the inclusion of the above copyright
  21.  * notice.  This software and information or any other copies thereof may
  22.  * not be provided or otherwise made available to any other person.
  23.  *
  24.  * Notwithstanding any other lease or license that may pertain to, or
  25.  * accompany the delivery of, this computer software and information, the
  26.  * rights of the Government regarding its use, reproduction and disclosure
  27.  * are as set forth in Section 52.227-19 of the FARS Computer
  28.  * Software-Restricted Rights clause.
  29.  * 
  30.  * Use, duplication, or disclosure by the Government is subject to
  31.  * restrictions as set forth in subparagraph (c)(1)(ii) of the Rights in
  32.  * Technical Data and Computer Software clause at DFARS 252.227-7013.
  33.  * Contractor/Manufacturer is Rogue Wave Software, Inc.,
  34.  * P.O. Box 2328, Corvallis, Oregon 97339.
  35.  *
  36.  * This computer software and information is distributed with "restricted
  37.  * rights."  Use, duplication or disclosure is subject to restrictions as
  38.  * set forth in NASA FAR SUP 18-52.227-79 (April 1985) "Commercial
  39.  * Computer Software-Restricted Rights (April 1985)."  If the Clause at
  40.  * 18-52.227-74 "Rights in Data General" is specified in the contract,
  41.  * then the "Alternate III" clause applies.
  42.  *
  43.  **************************************************************************/
  44.  
  45. #ifndef _RWSTD_NO_NAMESPACE
  46. namespace std {
  47. #endif
  48.  
  49.  
  50. /*****************************************************************
  51. *                                                                *
  52. *                 VALARRAY MEMBER FUNCTIONS                      *
  53. *                                                                *
  54. ******************************************************************/
  55.  
  56.  
  57. // unary operators
  58.  
  59.     template<class T>
  60.     valarray<T> valarray<T>::operator+() const
  61.     {
  62.       valarray<T> tmp_array(size());
  63.       
  64.       for(size_t ind=0; ind< size(); ind++ )
  65.        tmp_array[ind] = +memory_array[ind];
  66.  
  67.       _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  68.  
  69.       _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  70.       _tmp_ret->length = size();
  71.  
  72.       tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  73.  
  74.       return _tmp_ret;
  75.     }
  76.  
  77.     template <class T>
  78.     valarray<T> valarray<T>::operator-() const
  79.     {
  80.       valarray<T> tmp_array(size());
  81.       
  82.       for(size_t ind=0; ind< size(); ind++ )
  83.        tmp_array[ind] = -memory_array[ind];
  84.  
  85.       _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  86.  
  87.       _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  88.       _tmp_ret->length = size();
  89.  
  90.       tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  91.  
  92.       return _tmp_ret;
  93.     }
  94.  
  95.  
  96.     #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  97.     template <class T>
  98.     valarray<T> valarray<T>::operator~() const
  99.     {
  100.       valarray<T> tmp_array(size());
  101.  
  102.       for(size_t ind=0; ind< size(); ind++ )
  103.        tmp_array[ind] = ~memory_array[ind];
  104.  
  105.       _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  106.  
  107.       _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  108.       _tmp_ret->length = size();
  109.  
  110.       tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  111.  
  112.       return _tmp_ret;
  113.     }
  114.  
  115.     template <class T>
  116.     valarray<bool> valarray<T>::operator!() const
  117.     {
  118.       valarray<bool> tmp_array(size());
  119.  
  120.       for(size_t ind=0; ind< size(); ind++ )
  121.        tmp_array[ind] = !memory_array[ind];
  122.  
  123.       _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  124.  
  125.       _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  126.       _tmp_ret->length = size();
  127.  
  128.       tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  129.  
  130.       return _tmp_ret;
  131.     }
  132.     #endif
  133.  
  134. // computed assignment
  135.  
  136.     template <class T>
  137.     valarray<T>& valarray<T>::operator*= (const valarray<T>& array)
  138.     {
  139.       size_t upper_l = ( size() < array.size() ) ? size() : array.size();
  140.  
  141.       for(size_t ind=0; ind < upper_l; ind++)
  142.        memory_array[ind]*= array[ind];
  143.  
  144.       return *this;
  145.     }
  146.  
  147.     template <class T>
  148.     valarray<T>& valarray<T>::operator/= (const valarray<T>& array)
  149.     {
  150.       size_t upper_l = ( size() < array.size() ) ? size() : array.size();
  151.  
  152.       for(size_t ind=0; ind < upper_l; ind++)
  153.        memory_array[ind]/= array[ind];
  154.  
  155.       return *this;
  156.     }
  157.  
  158.     template <class T>
  159.     valarray<T>& valarray<T>::operator+= (const valarray<T>& array)
  160.     {
  161.       size_t upper_l = ( size() < array.size() ) ? size() : array.size();
  162.  
  163.       for(size_t ind=0; ind < upper_l; ind++)
  164.        memory_array[ind]+= array[ind];
  165.  
  166.       return *this;
  167.     }
  168.  
  169.     template <class T>
  170.     valarray<T>& valarray<T>::operator-= (const valarray<T>& array)
  171.     {
  172.       size_t upper_l = ( size() < array.size() ) ? size() : array.size();
  173.  
  174.       for(size_t ind=0; ind < upper_l; ind++)
  175.        memory_array[ind]-= array[ind];
  176.  
  177.       return *this;
  178.     }
  179.  
  180.     #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  181.     template <class T>
  182.     valarray<T>& valarray<T>::operator%= (const valarray<T>& array)
  183.     {
  184.       size_t upper_l = ( size() < array.size() ) ? size() : array.size();
  185.  
  186.       for(size_t ind=0; ind < upper_l; ind++)
  187.        memory_array[ind]%= array[ind];
  188.  
  189.       return *this;
  190.     }
  191.  
  192.     template <class T>
  193.     valarray<T>& valarray<T>::operator^= (const valarray<T>& array)
  194.     {
  195.       size_t upper_l = ( size() < array.size() ) ? size() : array.size();
  196.  
  197.       for(size_t ind=0; ind < upper_l; ind++)
  198.        memory_array[ind]^= array[ind];
  199.  
  200.       return *this;
  201.     }
  202.  
  203.     template <class T>
  204.     valarray<T>& valarray<T>::operator&= (const valarray<T>& array)
  205.     {
  206.       size_t upper_l = ( size() < array.size() ) ? size() : array.size();
  207.  
  208.       for(size_t ind=0; ind < upper_l; ind++)
  209.        memory_array[ind]&= array[ind];
  210.  
  211.       return *this;
  212.     }
  213.  
  214.     template <class T>
  215.     valarray<T>& valarray<T>::operator|= (const valarray<T>& array)
  216.     {
  217.       size_t upper_l = ( size() < array.size() ) ? size() : array.size();
  218.  
  219.       for(size_t ind=0; ind < upper_l; ind++)
  220.        memory_array[ind]|= array[ind];
  221.  
  222.       return *this;
  223.     }
  224.  
  225.     template <class T>
  226.     valarray<T>& valarray<T>::operator<<= (const valarray<T>& array)
  227.     {
  228.       size_t upper_l = ( size() < array.size() ) ? size() : array.size();
  229.  
  230.       for(size_t ind=0; ind < upper_l; ind++)
  231.        memory_array[ind]<<= array[ind];
  232.  
  233.       return *this;
  234.     }
  235.  
  236.     template <class T>
  237.     valarray<T>& valarray<T>::operator>>= (const valarray<T>& array)
  238.     {
  239.       size_t upper_l = ( size() < array.size() ) ? size() : array.size();
  240.  
  241.       for(size_t ind=0; ind < upper_l; ind++)
  242.        memory_array[ind]>>= array[ind];
  243.  
  244.       return *this;
  245.     }
  246.     #endif
  247.  
  248.     template <class T>
  249.     valarray<T>& valarray<T>::operator*= (const T& val)
  250.     {
  251.       for(size_t ind=0; ind < size(); ind++)
  252.        memory_array[ind]*= val;
  253.  
  254.       return *this;
  255.     }
  256.  
  257.     template <class T>
  258.     valarray<T>& valarray<T>::operator/= (const T& val)
  259.     {
  260.       for(size_t ind=0; ind < size(); ind++)
  261.        memory_array[ind]/= val;
  262.  
  263.       return *this;
  264.     }
  265.  
  266.     template <class T>
  267.     valarray<T>& valarray<T>::operator+= (const T& val)
  268.     {
  269.       for(size_t ind=0; ind < size(); ind++)
  270.        memory_array[ind]+= val;
  271.  
  272.       return *this;
  273.     }
  274.  
  275.     template <class T>
  276.     valarray<T>& valarray<T>::operator-= (const T& val)
  277.     {
  278.       for(size_t ind=0; ind < size(); ind++)
  279.        memory_array[ind]-= val;
  280.  
  281.       return *this;
  282.     }
  283.  
  284.     #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  285.     template <class T>
  286.     valarray<T>& valarray<T>::operator%= (const T& val)
  287.     {
  288.       for(size_t ind=0; ind < size(); ind++)
  289.        memory_array[ind]%= val;
  290.  
  291.       return *this;
  292.     }
  293.  
  294.     template <class T>
  295.     valarray<T>& valarray<T>::operator^= (const T& val)
  296.     {
  297.       for(size_t ind=0; ind < size(); ind++)
  298.        memory_array[ind]^= val;
  299.  
  300.       return *this;
  301.     }
  302.  
  303.     template <class T>
  304.     valarray<T>& valarray<T>::operator&= (const T& val)
  305.     {
  306.       for(size_t ind=0; ind < size(); ind++)
  307.        memory_array[ind]&= val;
  308.  
  309.       return *this;
  310.     }
  311.  
  312.     template <class T>
  313.     valarray<T>& valarray<T>::operator|= (const T& val)
  314.     {
  315.       for(size_t ind=0; ind < size(); ind++)
  316.        memory_array[ind]|= val;
  317.  
  318.       return *this;
  319.     }
  320.  
  321.     template <class T>
  322.     valarray<T>& valarray<T>::operator<<= (const T& val)
  323.     {
  324.       for(size_t ind=0; ind < size(); ind++)
  325.        memory_array[ind]<<= val;
  326.  
  327.       return *this;
  328.     }
  329.  
  330.     template <class T>
  331.     valarray<T>& valarray<T>::operator>>= (const T& val)
  332.     {
  333.       for(size_t ind=0; ind < size(); ind++)
  334.        memory_array[ind]>>= val;
  335.  
  336.       return *this;
  337.     }
  338.     #endif
  339.  
  340. // other valarray member functions
  341.  
  342.    template <class T>
  343.    T valarray<T>::sum() const
  344.    {
  345.      T tmp;
  346.      if ( size() > 0 )
  347.      {
  348.        tmp = memory_array[0];
  349.        for(size_t ind=1; ind<size(); ind++)
  350.         tmp+= memory_array[ind];
  351.      }
  352.  
  353.       return tmp;
  354.    }
  355.  
  356.    template <class T>
  357.    valarray<T> valarray<T>::shift(int sh) const
  358.    {
  359.       valarray<T> tmp_array(T(),size());
  360.       
  361.       int right=0;
  362.       int left=0;
  363.  
  364.       if ( sh < 0 ) right = -sh;
  365.       else left = sh;
  366.  
  367.       for(size_t ind=left; ind< (size()-right); ind++ )
  368.        tmp_array[ind+right-left] = memory_array[ind];
  369.  
  370.       _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  371.  
  372.       _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  373.       _tmp_ret->length = size();
  374.  
  375.       tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  376.  
  377.       return _tmp_ret;
  378.    } 
  379.  
  380.    template <class T>
  381.    valarray<T> valarray<T>::cshift(int sh) const
  382.    {
  383.       valarray<T> tmp_array(T(),size());
  384.       
  385.       if ( sh >= 0 )
  386.       {
  387.         for(size_t ind=0; ind< size(); ind++ )
  388.           tmp_array[ind] = memory_array[(ind+sh)%size()];
  389.       }
  390.       else
  391.       {
  392.        for(size_t ind=size()+sh; ind< (2*size()+sh); ind++ )
  393.         tmp_array[ind-size()-sh] = memory_array[ind%size()];
  394.       }
  395.  
  396.       _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  397.  
  398.       _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  399.       _tmp_ret->length = size();
  400.  
  401.       tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  402.  
  403.       return _tmp_ret;
  404.    } 
  405.  
  406.    template <class T>
  407.    valarray<T> valarray<T>::apply(T func(T)) const
  408.    {
  409.       valarray<T> tmp_array(size());
  410.       
  411.        for(size_t ind=0; ind< size(); ind++ )
  412.         tmp_array[ind] = func(memory_array[ind]);
  413.  
  414.       _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  415.  
  416.       _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  417.       _tmp_ret->length = size();
  418.  
  419.       tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  420.  
  421.       return _tmp_ret;
  422.    } 
  423.  
  424.    template <class T>
  425.    valarray<T> valarray<T>::apply(T func(const T&)) const
  426.    {
  427.       valarray<T> tmp_array(size());
  428.       
  429.        for(size_t ind=0; ind< size(); ind++ )
  430.         tmp_array[ind] = func(memory_array[ind]);
  431.  
  432.       _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  433.  
  434.       _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  435.       _tmp_ret->length = size();
  436.  
  437.       tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  438.  
  439.       return _tmp_ret;
  440.    } 
  441.  
  442. // operator[] for slice
  443.  
  444.    template <class T> 
  445.    valarray<T> valarray<T>::operator[](slice sl) const
  446.    {
  447.       valarray<T> tmp_array(sl.length());
  448.       
  449.       size_t ind = sl.start();
  450.       size_t cpt = 0; 
  451.  
  452.       while( cpt < sl.length() )
  453.       {
  454.         tmp_array[cpt] = memory_array[ind];
  455.         ind+= sl.stride();
  456.         cpt++;
  457.       }
  458.  
  459.       _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  460.  
  461.       _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  462.       _tmp_ret->length = sl.length();
  463.  
  464.       tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  465.  
  466.       return _tmp_ret;
  467.    }
  468.  
  469. // copy ctor and assignment for slice
  470.  
  471.    template <class T>
  472.    valarray<T>::valarray(const slice_array<T>& sl_ar)
  473.    {
  474.       valarray<T> tmp_array(sl_ar.get_slice().length());
  475.       
  476.       size_t ind = sl_ar.get_slice().start();
  477.       size_t cpt = 0; 
  478.  
  479.       while( cpt < sl_ar.get_slice().length() )
  480.       {
  481.         tmp_array[cpt] = (*(sl_ar.get_ref_mem_array()))[ind];
  482.         ind+= sl_ar.get_slice().stride();
  483.         cpt++;
  484.       }
  485.    memory_array._replace(tmp_array._RW_get_memory_array()._RW_get_storage(),sl_ar.get_slice().length());
  486.  
  487.       tmp_array._RW_get_memory_array_adr()->_RW_invalidate();   
  488.    }
  489.    
  490.    template <class T>
  491.    valarray<T>& valarray<T>::operator= (const slice_array<T>& sl_ar)
  492.    { 
  493.       valarray<T> tmp_array(sl_ar.get_slice().length());
  494.       
  495.       size_t ind = sl_ar.get_slice().start();
  496.       size_t cpt = 0; 
  497.  
  498.       while( cpt < sl_ar.get_slice().length() )
  499.       {
  500.         tmp_array[cpt] = (*(sl_ar.get_ref_mem_array()))[ind];
  501.         ind+= sl_ar.get_slice().stride();
  502.         cpt++;
  503.       }
  504.  
  505.       if ( &memory_array == sl_ar.get_ref_mem_array() )
  506.       memory_array._RW_resize_without_copy(0); 
  507.  
  508.       memory_array._replace(tmp_array._RW_get_memory_array()._RW_get_storage(),sl_ar.get_slice().length());
  509.  
  510.       tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  511.  
  512.       return *this;
  513.    }
  514.  
  515.  // operator[] for gslice
  516.  
  517.    template <class T> 
  518.    valarray<T> valarray<T>::operator[](const gslice& sl) const
  519.    {
  520.       valarray<T> tmp_array(sl.ind_numb());
  521.       
  522.       gslice *gsl = (gslice *)&sl;
  523.  
  524.       size_t ind = gsl->next_ind();
  525.       size_t cpt = 0;
  526.  
  527.       while( !sl.is_reseted() )
  528.       {
  529.         tmp_array[cpt] = memory_array[ind];
  530.         ind= gsl->next_ind();
  531.         cpt++;
  532.       }
  533.  
  534.       _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  535.  
  536.       _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  537.       _tmp_ret->length = tmp_array.size();
  538.  
  539.       tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  540.  
  541.       return _tmp_ret;
  542.    }
  543.  
  544. // copy ctor and assignment for gslice
  545.  
  546.    template <class T>
  547.    valarray<T>::valarray(const gslice_array<T>& sl_ar)
  548.    {
  549.       gslice sl(sl_ar.get_slice());
  550.       valarray<T> tmp_array(sl.ind_numb());
  551.  
  552.       size_t ind = sl.next_ind();
  553.       size_t cpt = 0;
  554.  
  555.       while( !sl.is_reseted() )
  556.       {
  557.         tmp_array[cpt] = (*(sl_ar.get_ref_mem_array()))[ind];
  558.         ind= sl.next_ind();
  559.         cpt++;
  560.       }
  561.  
  562.       memory_array._replace(tmp_array._RW_get_memory_array()._RW_get_storage(),tmp_array.size());
  563.  
  564.       tmp_array._RW_get_memory_array_adr()->_RW_invalidate();   
  565.    }
  566.  
  567.    template <class T>
  568.    valarray<T>& valarray<T>::operator= (const gslice_array<T>& sl_ar)
  569.    { 
  570.       gslice sl(sl_ar.get_slice());
  571.       valarray<T> tmp_array(sl.ind_numb());
  572.  
  573.       size_t ind = sl.next_ind();
  574.       size_t cpt = 0;
  575.  
  576.       while( !sl.is_reseted() )
  577.       {
  578.         tmp_array[cpt] = (*(sl_ar.get_ref_mem_array()))[ind];
  579.         ind= sl.next_ind();
  580.         cpt++;
  581.       }
  582.  
  583.       if ( &memory_array == sl_ar.get_ref_mem_array() )
  584.       memory_array._RW_resize_without_copy(0); 
  585.  
  586.       memory_array._replace(tmp_array._RW_get_memory_array()._RW_get_storage(),tmp_array.size());
  587.  
  588.       tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  589.  
  590.       return *this;
  591.    }
  592.  
  593.  
  594. // operator[] for valarray[valarray<bool>] used with mask_array
  595. #ifndef _MSC_VER
  596.    template <class T> 
  597.    valarray<T> valarray<T>::operator[](const valarray<bool>& array) const
  598.    {
  599.       size_t iter,size =0;
  600.  
  601.       for(iter=0; iter < array.size(); iter++ )
  602.        if ( array[iter] ) size++;
  603.  
  604.       valarray<T> tmp_array(size);
  605.       
  606.       size_t cpt = 0; 
  607.  
  608.       for( iter=0; iter < array.size(); iter++ )
  609.        if ( array[iter] ) tmp_array[cpt++] = memory_array[iter];
  610.  
  611.       _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  612.  
  613.       _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  614.       _tmp_ret->length = size;
  615.  
  616.       tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  617.  
  618.       return _tmp_ret;
  619.    }
  620. #endif // _MSC_VER
  621.  
  622. // copy ctor and assignment for mask_array
  623.  
  624.    template <class T>
  625.    valarray<T>::valarray(const mask_array<T>& mask)
  626.    {
  627.  
  628.       mask_array<T> *msk = (mask_array<T> *)&mask;
  629.       valarray<bool>* sec = msk->get_array_pt();
  630.  
  631.       size_t iter,size =0;
  632.  
  633.       for(iter=0; iter < sec->size(); iter++ )
  634.        if ( (*sec)[iter] ) size++;
  635.  
  636.       valarray<T> tmp_array(size);
  637.       
  638.       size_t cpt = 0; 
  639.  
  640.       for( iter=0; iter < sec->size(); iter++ )
  641.        if ( (*sec)[iter] ) tmp_array[cpt++] = (*(mask.get_ref_mem_array()))[iter];
  642.  
  643.       memory_array._replace(tmp_array._RW_get_memory_array()._RW_get_storage(),size);
  644.  
  645.       tmp_array._RW_get_memory_array_adr()->_RW_invalidate();   
  646.    }
  647.  
  648.    template <class T>
  649.    valarray<T>& valarray<T>::operator= (const mask_array<T>& mask)
  650.    { 
  651.       mask_array<T> *msk = (mask_array<T> *)&mask;
  652.       valarray<bool>* sec = msk->get_array_pt();
  653.  
  654.       size_t iter,size =0;
  655.  
  656.       for(iter=0; iter < sec->size(); iter++ )
  657.        if ( (*sec)[iter] ) size++;
  658.  
  659.       valarray<T> tmp_array(size);
  660.       
  661.       size_t cpt = 0; 
  662.  
  663.       for( iter=0; iter < sec->size(); iter++ )
  664.        if ( (*sec)[iter] ) tmp_array[cpt++] = (*(mask.get_ref_mem_array()))[iter];
  665.  
  666.       if ( &memory_array == mask.get_ref_mem_array() )
  667.       memory_array._RW_resize_without_copy(0); 
  668.  
  669.       memory_array._replace(tmp_array._RW_get_memory_array()._RW_get_storage(),size);
  670.  
  671.       tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  672.  
  673.       return *this;
  674.    }
  675.  
  676. // operator[] for valarray[valarray<size_t>] used with indirect_array
  677.  
  678.   template <class T> 
  679.   valarray<T> valarray<T>::operator[](const valarray<size_t>& array) const
  680.    {
  681.       valarray<T> tmp_array(array.size());
  682.  
  683.       for( size_t iter=0; iter < array.size(); iter++ )
  684.        tmp_array[iter] = memory_array[array[iter]];
  685.  
  686.       _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  687.  
  688.       _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  689.       _tmp_ret->length = array.size();
  690.  
  691.       tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  692.  
  693.       return _tmp_ret;
  694.    }
  695.  
  696. // copy ctor and assignment for indirect_array
  697.  
  698.    template <class T>
  699.    valarray<T>::valarray(const indirect_array<T>& indir)
  700.    {
  701.  
  702.       indirect_array<T> *indr= (indirect_array<T> *)&indir;
  703.       valarray<size_t>* sec = indr->get_array_pt();
  704.  
  705.       valarray<T> tmp_array(sec->size());
  706.       
  707.       size_t cpt = 0; 
  708.  
  709.       for(size_t iter=0; iter < sec->size(); iter++ )
  710.        tmp_array[cpt++] = (*(indir.get_ref_mem_array()))[(*sec)[iter]];
  711.  
  712.       memory_array._replace(tmp_array._RW_get_memory_array()._RW_get_storage(),sec->size());
  713.  
  714.       tmp_array._RW_get_memory_array_adr()->_RW_invalidate();   
  715.    }
  716.  
  717.  
  718.    template <class T>
  719.    valarray<T>& valarray<T>::operator= (const indirect_array<T>& indir)
  720.    { 
  721.       indirect_array<T> *indr= (indirect_array<T> *)&indir;
  722.       valarray<size_t>* sec = indr->get_array_pt();
  723.  
  724.       valarray<T> tmp_array(sec->size());
  725.       
  726.       size_t cpt = 0; 
  727.  
  728.       for(size_t iter=0; iter < sec->size(); iter++ )
  729.        tmp_array[cpt++] = (*(indir.get_ref_mem_array()))[(*sec)[iter]];
  730.  
  731.       if ( &memory_array == indir.get_ref_mem_array() )
  732.       memory_array._RW_resize_without_copy(0); 
  733.  
  734.       memory_array._replace(tmp_array._RW_get_memory_array()._RW_get_storage(),sec->size());
  735.  
  736.       tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  737.  
  738.       return *this;
  739.    }
  740.  
  741.  
  742. /*
  743.  *
  744.  *   VALARRAY NON MEMBER FUNCTIONS
  745.  *
  746.  */
  747.  
  748.  
  749.  template<class T>
  750.  valarray<T> operator* (const valarray<T>& a, const valarray<T>& b)
  751.  {
  752.    size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  753.    valarray<T> tmp_array(length);
  754.  
  755.    for(size_t ind=0; ind< length; ind++ )
  756.     tmp_array[ind] = a[ind]*b[ind];
  757.  
  758.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  759.  
  760.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  761.    _tmp_ret->length = length;
  762.  
  763.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  764.  
  765.    return _tmp_ret;
  766.  }
  767.  
  768.  template<class T>
  769.  valarray<T> operator/ (const valarray<T>& a, const valarray<T>& b)
  770.  {
  771.    size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  772.    valarray<T> tmp_array(length);
  773.  
  774.    for(size_t ind=0; ind< length; ind++ )
  775.     tmp_array[ind] = a[ind]/b[ind];
  776.  
  777.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  778.  
  779.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  780.    _tmp_ret->length = length;
  781.  
  782.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  783.  
  784.    return _tmp_ret;
  785.  }
  786.  
  787.  template<class T>
  788.  valarray<T> operator% (const valarray<T>& a, const valarray<T>& b)
  789.  {
  790.    size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  791.    valarray<T> tmp_array(length);
  792.  
  793.    for(size_t ind=0; ind< length; ind++ )
  794.     tmp_array[ind] = a[ind]%b[ind];
  795.  
  796.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  797.  
  798.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  799.    _tmp_ret->length = length;
  800.  
  801.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  802.  
  803.    return _tmp_ret;
  804.  }
  805.  
  806.  template<class T>
  807.  valarray<T> operator+ (const valarray<T>& a, const valarray<T>& b)
  808.  {
  809.    size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  810.    valarray<T> tmp_array(length);
  811.  
  812.    for(size_t ind=0; ind< length; ind++ )
  813.     tmp_array[ind] = a[ind]+b[ind];
  814.  
  815.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  816.  
  817.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  818.    _tmp_ret->length = length;
  819.  
  820.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  821.  
  822.    return _tmp_ret;
  823.  }
  824.  
  825.  template<class T>
  826.  valarray<T> operator- (const valarray<T>& a, const valarray<T>& b)
  827.  {
  828.    size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  829.    valarray<T> tmp_array(length);
  830.  
  831.    for(size_t ind=0; ind< length; ind++ )
  832.     tmp_array[ind] = a[ind]-b[ind];
  833.  
  834.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  835.  
  836.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  837.    _tmp_ret->length = length;
  838.  
  839.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  840.  
  841.    return _tmp_ret;
  842.  }
  843.  
  844.  
  845.  template<class T>
  846.  valarray<T> operator^ (const valarray<T>& a, const valarray<T>& b)
  847.  {
  848.    size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  849.    valarray<T> tmp_array(length);
  850.  
  851.    for(size_t ind=0; ind< length; ind++ )
  852.     tmp_array[ind] = a[ind]^b[ind];
  853.  
  854.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  855.  
  856.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  857.    _tmp_ret->length = length;
  858.  
  859.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  860.  
  861.    return _tmp_ret;
  862.  }
  863.  
  864.  template<class T>
  865.  valarray<T> operator& (const valarray<T>& a, const valarray<T>& b)
  866.  {
  867.    size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  868.    valarray<T> tmp_array(length);
  869.  
  870.    for(size_t ind=0; ind< length; ind++ )
  871.     tmp_array[ind] = a[ind]&b[ind];
  872.  
  873.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  874.  
  875.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  876.    _tmp_ret->length = length;
  877.  
  878.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  879.  
  880.    return _tmp_ret;
  881.  }
  882.  
  883.  template<class T>
  884.  valarray<T> operator| (const valarray<T>& a, const valarray<T>& b)
  885.  {
  886.    size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  887.    valarray<T> tmp_array(length);
  888.  
  889.    for(size_t ind=0; ind< length; ind++ )
  890.     tmp_array[ind] = a[ind]|b[ind];
  891.  
  892.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  893.  
  894.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  895.    _tmp_ret->length = length;
  896.  
  897.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  898.  
  899.    return _tmp_ret;
  900.  }
  901.  
  902.  template<class T>
  903.  valarray<T> operator<< (const valarray<T>& a, const valarray<T>& b)
  904.  {
  905.    size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  906.    valarray<T> tmp_array(length);
  907.  
  908.    for(size_t ind=0; ind< length; ind++ )
  909.     tmp_array[ind] = a[ind]<<b[ind];
  910.  
  911.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  912.  
  913.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  914.    _tmp_ret->length = length;
  915.  
  916.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  917.  
  918.    return _tmp_ret;
  919.  }
  920.  
  921.  template<class T>
  922.  valarray<T> operator>> (const valarray<T>& a, const valarray<T>& b)
  923.  {
  924.    size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  925.    valarray<T> tmp_array(length);
  926.  
  927.    for(size_t ind=0; ind< length; ind++ )
  928.     tmp_array[ind] = a[ind]>>b[ind];
  929.  
  930.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  931.  
  932.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  933.    _tmp_ret->length = length;
  934.  
  935.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  936.  
  937.    return _tmp_ret;
  938.  }
  939.  
  940.  template<class T>
  941.  valarray<bool> operator&& (const valarray<T>& a, const valarray<T>& b)
  942.  {
  943.    size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  944.    valarray<bool> tmp_array(length);
  945.  
  946.    for(size_t ind=0; ind< length; ind++ )
  947.     tmp_array[ind] = a[ind] && b[ind];
  948.  
  949.    _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  950.  
  951.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  952.    _tmp_ret->length = length;
  953.  
  954.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  955.  
  956.    return _tmp_ret;
  957.  }
  958.  
  959.  template<class T>
  960.  valarray<bool> operator|| (const valarray<T>& a, const valarray<T>& b)
  961.  {
  962.    size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  963.    valarray<bool> tmp_array(length);
  964.  
  965.    for(size_t ind=0; ind< length; ind++ )
  966.     tmp_array[ind] = a[ind] || b[ind];
  967.  
  968.    _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  969.  
  970.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  971.    _tmp_ret->length = length;
  972.  
  973.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  974.  
  975.    return _tmp_ret;
  976.  }
  977.  
  978. // with non array second parameter
  979.  
  980.  template<class T>
  981.  valarray<T> operator* (const valarray<T>& a, const T& b)
  982.  {
  983.    size_t length= a.size();
  984.    valarray<T> tmp_array(length);
  985.  
  986.    for(size_t ind=0; ind< length; ind++ )
  987.     tmp_array[ind] = a[ind]*b;
  988.  
  989.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  990.  
  991.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  992.    _tmp_ret->length = length;
  993.  
  994.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  995.  
  996.    return _tmp_ret;
  997.  }
  998.  
  999.  template<class T>
  1000.  valarray<T> operator/ (const valarray<T>& a, const T& b)
  1001.  {
  1002.    size_t length= a.size();
  1003.    valarray<T> tmp_array(length);
  1004.  
  1005.    for(size_t ind=0; ind< length; ind++ )
  1006.     tmp_array[ind] = a[ind]/b;
  1007.  
  1008.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1009.  
  1010.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1011.    _tmp_ret->length = length;
  1012.  
  1013.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1014.  
  1015.    return _tmp_ret;
  1016.  }
  1017.  
  1018.  template<class T>
  1019.  valarray<T> operator% (const valarray<T>& a,const T& b)
  1020.  {
  1021.    size_t length= a.size();
  1022.    valarray<T> tmp_array(length);
  1023.  
  1024.    for(size_t ind=0; ind< length; ind++ )
  1025.     tmp_array[ind] = a[ind]%b;
  1026.  
  1027.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1028.  
  1029.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1030.    _tmp_ret->length = length;
  1031.  
  1032.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1033.  
  1034.    return _tmp_ret;
  1035.  }
  1036.  
  1037.  template<class T>
  1038.  valarray<T> operator+ (const valarray<T>& a, const T& b)
  1039.  {
  1040.    size_t length= a.size();
  1041.    valarray<T> tmp_array(length);
  1042.  
  1043.    for(size_t ind=0; ind< length; ind++ )
  1044.     tmp_array[ind] = a[ind]+b;
  1045.  
  1046.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1047.  
  1048.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1049.    _tmp_ret->length = length;
  1050.  
  1051.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1052.  
  1053.    return _tmp_ret;
  1054.  }
  1055.  
  1056.  template<class T>
  1057.  valarray<T> operator- (const valarray<T>& a, const T& b)
  1058.  {
  1059.    size_t length= a.size();
  1060.    valarray<T> tmp_array(length);
  1061.  
  1062.    for(size_t ind=0; ind< length; ind++ )
  1063.     tmp_array[ind] = a[ind]-b;
  1064.  
  1065.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1066.  
  1067.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1068.    _tmp_ret->length = length;
  1069.  
  1070.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1071.  
  1072.    return _tmp_ret;
  1073.  }
  1074.  
  1075.  
  1076.  template<class T>
  1077.  valarray<T> operator^ (const valarray<T>& a, const T& b)
  1078.  {
  1079.    size_t length= a.size();
  1080.    valarray<T> tmp_array(length);
  1081.  
  1082.    for(size_t ind=0; ind< length; ind++ )
  1083.     tmp_array[ind] = a[ind]^b;
  1084.  
  1085.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1086.  
  1087.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1088.    _tmp_ret->length = length;
  1089.  
  1090.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1091.  
  1092.    return _tmp_ret;
  1093.  }
  1094.  
  1095.  template<class T>
  1096.  valarray<T> operator& (const valarray<T>& a, const T& b)
  1097.  {
  1098.    size_t length= a.size();
  1099.    valarray<T> tmp_array(length);
  1100.  
  1101.    for(size_t ind=0; ind< length; ind++ )
  1102.     tmp_array[ind] = a[ind]&b;
  1103.  
  1104.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1105.  
  1106.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1107.    _tmp_ret->length = length;
  1108.  
  1109.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1110.  
  1111.    return _tmp_ret;
  1112.  }
  1113.  
  1114.  template<class T>
  1115.  valarray<T> operator| (const valarray<T>& a, const T& b)
  1116.  {
  1117.    size_t length= a.size();
  1118.    valarray<T> tmp_array(length);
  1119.  
  1120.    for(size_t ind=0; ind< length; ind++ )
  1121.     tmp_array[ind] = a[ind]|b;
  1122.  
  1123.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1124.  
  1125.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1126.    _tmp_ret->length = length;
  1127.  
  1128.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1129.  
  1130.    return _tmp_ret;
  1131.  }
  1132.  
  1133.  template<class T>
  1134.  valarray<T> operator<< (const valarray<T>& a, const T& b)
  1135.  {
  1136.    size_t length= a.size();
  1137.    valarray<T> tmp_array(length);
  1138.  
  1139.    for(size_t ind=0; ind< length; ind++ )
  1140.     tmp_array[ind] = a[ind]<<b;
  1141.  
  1142.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1143.  
  1144.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1145.    _tmp_ret->length = length;
  1146.  
  1147.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1148.  
  1149.    return _tmp_ret;
  1150.  }
  1151.  
  1152.  template<class T>
  1153.  valarray<T> operator>> (const valarray<T>& a, const T& b)
  1154.  {
  1155.    size_t length= a.size();
  1156.    valarray<T> tmp_array(length);
  1157.  
  1158.    for(size_t ind=0; ind< length; ind++ )
  1159.     tmp_array[ind] = a[ind]>>b;
  1160.  
  1161.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1162.  
  1163.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1164.    _tmp_ret->length = length;
  1165.  
  1166.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1167.  
  1168.    return _tmp_ret;
  1169.  }
  1170.  
  1171.  template<class T>
  1172.  valarray<T> operator&& (const valarray<T>& a, const T& b)
  1173.  {
  1174.    size_t length= a.size();
  1175.    valarray<T> tmp_array(length);
  1176.  
  1177.    for(size_t ind=0; ind< length; ind++ )
  1178.     tmp_array[ind] = a[ind] && b;
  1179.  
  1180.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1181.  
  1182.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1183.    _tmp_ret->length = length;
  1184.  
  1185.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1186.  
  1187.    return _tmp_ret;
  1188.  }
  1189.  
  1190.  template<class T>
  1191.  valarray<T> operator|| (const valarray<T>& a, const T& b)
  1192.  {
  1193.    size_t length= a.size();
  1194.    valarray<T> tmp_array(length);
  1195.  
  1196.    for(size_t ind=0; ind< length; ind++ )
  1197.     tmp_array[ind] = a[ind] || b;
  1198.  
  1199.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1200.  
  1201.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1202.    _tmp_ret->length = length;
  1203.  
  1204.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1205.  
  1206.    return _tmp_ret;
  1207.  }
  1208.  
  1209. // with non array first parameter
  1210.  
  1211.  template<class T>
  1212.  valarray<T> operator* (const T& a, const valarray<T>& b)
  1213.  {
  1214.    size_t length= b.size();
  1215.    valarray<T> tmp_array(length);
  1216.  
  1217.    for(size_t ind=0; ind< length; ind++ )
  1218.     tmp_array[ind] = a*b[ind];
  1219.  
  1220.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1221.  
  1222.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1223.    _tmp_ret->length = length;
  1224.  
  1225.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1226.  
  1227.    return _tmp_ret;
  1228.  }
  1229.  
  1230.  template<class T>
  1231.  valarray<T> operator/ (const T& a, const valarray<T>& b)
  1232.  {
  1233.    size_t length= b.size();
  1234.    valarray<T> tmp_array(length);
  1235.  
  1236.    for(size_t ind=0; ind< length; ind++ )
  1237.     tmp_array[ind] = a/b[ind];
  1238.  
  1239.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1240.  
  1241.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1242.    _tmp_ret->length = length;
  1243.  
  1244.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1245.  
  1246.    return _tmp_ret;
  1247.  }
  1248.  
  1249.  template<class T>
  1250.  valarray<T> operator% (const T& a, const valarray<T>& b)
  1251.  {
  1252.    size_t length= b.size();
  1253.    valarray<T> tmp_array(length);
  1254.  
  1255.    for(size_t ind=0; ind< length; ind++ )
  1256.     tmp_array[ind] = a%b[ind];
  1257.  
  1258.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1259.  
  1260.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1261.    _tmp_ret->length = length;
  1262.  
  1263.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1264.  
  1265.    return _tmp_ret;
  1266.  }
  1267.  
  1268.  template<class T>
  1269.  valarray<T> operator+ (const T& a, const valarray<T>& b)
  1270.  {
  1271.    size_t length= b.size();
  1272.    valarray<T> tmp_array(length);
  1273.  
  1274.    for(size_t ind=0; ind< length; ind++ )
  1275.     tmp_array[ind] = a+b[ind];
  1276.  
  1277.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1278.  
  1279.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1280.    _tmp_ret->length = length;
  1281.  
  1282.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1283.  
  1284.    return _tmp_ret;
  1285.  }
  1286.  
  1287.  template<class T>
  1288.  valarray<T> operator- (const T& a, const valarray<T>& b)
  1289.  {
  1290.    size_t length= b.size();
  1291.    valarray<T> tmp_array(length);
  1292.  
  1293.    for(size_t ind=0; ind< length; ind++ )
  1294.     tmp_array[ind] = a-b[ind];
  1295.  
  1296.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1297.  
  1298.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1299.    _tmp_ret->length = length;
  1300.  
  1301.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1302.  
  1303.    return _tmp_ret;
  1304.  }
  1305.  
  1306.  
  1307.  template<class T>
  1308.  valarray<T> operator^ (const T& a, const valarray<T>& b)
  1309.  {
  1310.    size_t length= b.size();
  1311.    valarray<T> tmp_array(length);
  1312.  
  1313.    for(size_t ind=0; ind< length; ind++ )
  1314.     tmp_array[ind] = a^b[ind];
  1315.  
  1316.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1317.  
  1318.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1319.    _tmp_ret->length = length;
  1320.  
  1321.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1322.  
  1323.    return _tmp_ret;
  1324.  }
  1325.  
  1326.  template<class T>
  1327.  valarray<T> operator& (const T& a, const valarray<T>& b)
  1328.  {
  1329.    size_t length= b.size();
  1330.    valarray<T> tmp_array(length);
  1331.  
  1332.    for(size_t ind=0; ind< length; ind++ )
  1333.     tmp_array[ind] = a&b[ind];
  1334.  
  1335.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1336.  
  1337.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1338.    _tmp_ret->length = length;
  1339.  
  1340.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1341.  
  1342.    return _tmp_ret;
  1343.  }
  1344.  
  1345.  template<class T>
  1346.  valarray<T> operator| (const T& a, const valarray<T>& b)
  1347.  {
  1348.    size_t length= b.size();
  1349.    valarray<T> tmp_array(length);
  1350.  
  1351.    for(size_t ind=0; ind< length; ind++ )
  1352.     tmp_array[ind] = a|b[ind];
  1353.  
  1354.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1355.  
  1356.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1357.    _tmp_ret->length = length;
  1358.  
  1359.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1360.  
  1361.    return _tmp_ret;
  1362.  }
  1363.  
  1364.  template<class T>
  1365.  valarray<T> operator<< (const T& a, const valarray<T>& b)
  1366.  {
  1367.    size_t length= b.size();
  1368.    valarray<T> tmp_array(length);
  1369.  
  1370.    for(size_t ind=0; ind< length; ind++ )
  1371.     tmp_array[ind] = a<<b[ind];
  1372.  
  1373.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1374.  
  1375.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1376.    _tmp_ret->length = length;
  1377.  
  1378.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1379.  
  1380.    return _tmp_ret;
  1381.  }
  1382.  
  1383.  template<class T>
  1384.  valarray<T> operator>> (const T& a, const valarray<T>& b)
  1385.  {
  1386.    size_t length= b.size();
  1387.    valarray<T> tmp_array(length);
  1388.  
  1389.    for(size_t ind=0; ind< length; ind++ )
  1390.     tmp_array[ind] = a>>b[ind];
  1391.  
  1392.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1393.  
  1394.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1395.    _tmp_ret->length = length;
  1396.  
  1397.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1398.  
  1399.    return _tmp_ret;
  1400.  }
  1401.  
  1402.  template<class T>
  1403.  valarray<T> operator&& (const T& a, const valarray<T>& b)
  1404.  {
  1405.    size_t length= b.size();
  1406.    valarray<T> tmp_array(length);
  1407.  
  1408.    for(size_t ind=0; ind< length; ind++ )
  1409.     tmp_array[ind] = a && b[ind];
  1410.  
  1411.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1412.  
  1413.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1414.    _tmp_ret->length = length;
  1415.  
  1416.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1417.  
  1418.    return _tmp_ret;
  1419.  }
  1420.  
  1421.  template<class T>
  1422.  valarray<T> operator|| (const T& a, const valarray<T>& b)
  1423.  {
  1424.    size_t length= b.size();
  1425.    valarray<T> tmp_array(length);
  1426.  
  1427.    for(size_t ind=0; ind< length; ind++ )
  1428.     tmp_array[ind] = a || b[ind];
  1429.  
  1430.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1431.  
  1432.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1433.    _tmp_ret->length = length;
  1434.  
  1435.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1436.  
  1437.    return _tmp_ret;
  1438.  }
  1439.  
  1440. // comparison operators
  1441.  
  1442.  template<class T>
  1443.  valarray<bool> operator== (const valarray<T>& a, const valarray<T>& b)
  1444.  {
  1445.    size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  1446.    valarray<bool> tmp_array(length);
  1447.  
  1448.    for(size_t ind=0; ind< length; ind++ )
  1449.     tmp_array[ind] = (a[ind]==b[ind]);
  1450.  
  1451.    _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1452.  
  1453.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1454.    _tmp_ret->length = length;
  1455.  
  1456.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1457.  
  1458.    return _tmp_ret;
  1459.  }
  1460.  
  1461.  template<class T>
  1462.  valarray<bool> operator!= (const valarray<T>& a, const valarray<T>& b)
  1463.  {
  1464.    size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  1465.    valarray<bool> tmp_array(length);
  1466.  
  1467.    for(size_t ind=0; ind< length; ind++ )
  1468.     tmp_array[ind] = (a[ind]!=b[ind]);
  1469.  
  1470.    _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1471.  
  1472.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1473.    _tmp_ret->length = length;
  1474.  
  1475.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1476.  
  1477.    return _tmp_ret;
  1478.  }
  1479.  
  1480.  template<class T>
  1481.  valarray<bool> operator< (const valarray<T>& a, const valarray<T>& b)
  1482.  {
  1483.    size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  1484.    valarray<bool> tmp_array(length);
  1485.  
  1486.    for(size_t ind=0; ind< length; ind++ )
  1487.     tmp_array[ind] = (a[ind]<b[ind]);
  1488.  
  1489.    _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1490.  
  1491.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1492.    _tmp_ret->length = length;
  1493.  
  1494.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1495.  
  1496.    return _tmp_ret;
  1497.  }
  1498.  
  1499.  template<class T>
  1500.  valarray<bool> operator> (const valarray<T>& a, const valarray<T>& b)
  1501.  {
  1502.    size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  1503.    valarray<bool> tmp_array(length);
  1504.  
  1505.    for(size_t ind=0; ind< length; ind++ )
  1506.     tmp_array[ind] = (a[ind]>b[ind]);
  1507.  
  1508.    _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1509.  
  1510.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1511.    _tmp_ret->length = length;
  1512.  
  1513.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1514.  
  1515.    return _tmp_ret;
  1516.  }
  1517.  
  1518.  template<class T>
  1519.  valarray<bool> operator<= (const valarray<T>& a, const valarray<T>& b)
  1520.  {
  1521.    size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  1522.    valarray<bool> tmp_array(length);
  1523.  
  1524.    for(size_t ind=0; ind< length; ind++ )
  1525.     tmp_array[ind] = (a[ind]<=b[ind]);
  1526.  
  1527.    _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1528.  
  1529.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1530.    _tmp_ret->length = length;
  1531.  
  1532.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1533.  
  1534.    return _tmp_ret;
  1535.  }
  1536.  
  1537.  template<class T>
  1538.  valarray<bool> operator>= (const valarray<T>& a, const valarray<T>& b)
  1539.  {
  1540.    size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  1541.    valarray<bool> tmp_array(length);
  1542.  
  1543.    for(size_t ind=0; ind< length; ind++ )
  1544.     tmp_array[ind] = (a[ind]>=b[ind]);
  1545.  
  1546.    _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1547.  
  1548.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1549.    _tmp_ret->length = length;
  1550.  
  1551.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1552.  
  1553.    return _tmp_ret;
  1554.  }
  1555.  
  1556. // comparison operators, non valarray second param
  1557.  
  1558.  template<class T>
  1559.  valarray<bool> operator== (const valarray<T>& a, const T& b)
  1560.  {
  1561.    size_t length= a.size();
  1562.    valarray<bool> tmp_array(length);
  1563.  
  1564.    for(size_t ind=0; ind< length; ind++ )
  1565.     tmp_array[ind] = (a[ind]==b);
  1566.  
  1567.    _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1568.  
  1569.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1570.    _tmp_ret->length = length;
  1571.  
  1572.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1573.  
  1574.    return _tmp_ret;
  1575.  }
  1576.  
  1577.  template<class T>
  1578.  valarray<bool> operator!= (const valarray<T>& a, const T& b)
  1579.  {
  1580.    size_t length= a.size();
  1581.    valarray<bool> tmp_array(length);
  1582.  
  1583.    for(size_t ind=0; ind< length; ind++ )
  1584.     tmp_array[ind] = (a[ind]!=b);
  1585.  
  1586.    _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1587.  
  1588.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1589.    _tmp_ret->length = length;
  1590.  
  1591.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1592.  
  1593.    return _tmp_ret;
  1594.  }
  1595.  
  1596.  template<class T>
  1597.  valarray<bool> operator< (const valarray<T>& a, const T& b)
  1598.  {
  1599.    size_t length= a.size();
  1600.    valarray<bool> tmp_array(length);
  1601.  
  1602.    for(size_t ind=0; ind< length; ind++ )
  1603.     tmp_array[ind] = (a[ind]<b);
  1604.  
  1605.    _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1606.  
  1607.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1608.    _tmp_ret->length = length;
  1609.  
  1610.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1611.  
  1612.    return _tmp_ret;
  1613.  }
  1614.  
  1615.  template<class T>
  1616.  valarray<bool> operator> (const valarray<T>& a, const T& b)
  1617.  {
  1618.    size_t length= a.size();
  1619.    valarray<bool> tmp_array(length);
  1620.  
  1621.    for(size_t ind=0; ind< length; ind++ )
  1622.     tmp_array[ind] = (a[ind]>b);
  1623.  
  1624.    _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1625.  
  1626.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1627.    _tmp_ret->length = length;
  1628.  
  1629.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1630.  
  1631.    return _tmp_ret;
  1632.  }
  1633.  
  1634.  template<class T>
  1635.  valarray<bool> operator<= (const valarray<T>& a, const T& b)
  1636.  {
  1637.    size_t length= a.size();
  1638.    valarray<bool> tmp_array(length);
  1639.  
  1640.    for(size_t ind=0; ind< length; ind++ )
  1641.     tmp_array[ind] = (a[ind]<=b);
  1642.  
  1643.    _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1644.  
  1645.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1646.    _tmp_ret->length = length;
  1647.  
  1648.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1649.  
  1650.    return _tmp_ret;
  1651.  }
  1652.  
  1653.  template<class T>
  1654.  valarray<bool> operator>= (const valarray<T>& a, const T& b)
  1655.  {
  1656.    size_t length= a.size();
  1657.    valarray<bool> tmp_array(length);
  1658.  
  1659.    for(size_t ind=0; ind< length; ind++ )
  1660.     tmp_array[ind] = (a[ind]>=b);
  1661.  
  1662.    _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1663.  
  1664.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1665.    _tmp_ret->length = length;
  1666.  
  1667.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1668.  
  1669.    return _tmp_ret;
  1670.  }
  1671.  
  1672. // comparison operators, non valarray first param
  1673.  
  1674.  template<class T>
  1675.  valarray<bool> operator== (const T& a, const valarray<T>& b)
  1676.  {
  1677.    size_t length= b.size();
  1678.    valarray<bool> tmp_array(length);
  1679.  
  1680.    for(size_t ind=0; ind< length; ind++ )
  1681.     tmp_array[ind] = (a==b[ind]);
  1682.  
  1683.    _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1684.  
  1685.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1686.    _tmp_ret->length = length;
  1687.  
  1688.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1689.  
  1690.    return _tmp_ret;
  1691.  }
  1692.  
  1693.  template<class T>
  1694.  valarray<bool> operator!= (const T& a, const valarray<T>& b)
  1695.  {
  1696.    size_t length= b.size();
  1697.    valarray<bool> tmp_array(length);
  1698.  
  1699.    for(size_t ind=0; ind< length; ind++ )
  1700.     tmp_array[ind] = (a!=b[ind]);
  1701.  
  1702.    _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1703.  
  1704.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1705.    _tmp_ret->length = length;
  1706.  
  1707.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1708.  
  1709.    return _tmp_ret;
  1710.  }
  1711.  
  1712.  template<class T>
  1713.  valarray<bool> operator< (const T& a, const valarray<T>& b)
  1714.  {
  1715.    size_t length= b.size();
  1716.    valarray<bool> tmp_array(length);
  1717.  
  1718.    for(size_t ind=0; ind< length; ind++ )
  1719.     tmp_array[ind] = (a<b[ind]);
  1720.  
  1721.    _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1722.  
  1723.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1724.    _tmp_ret->length = length;
  1725.  
  1726.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1727.  
  1728.    return _tmp_ret;
  1729.  }
  1730.  
  1731.  template<class T>
  1732.  valarray<bool> operator> (const T& a, const valarray<T>& b)
  1733.  {
  1734.    size_t length= b.size();
  1735.    valarray<bool> tmp_array(length);
  1736.  
  1737.    for(size_t ind=0; ind< length; ind++ )
  1738.     tmp_array[ind] = (a>b[ind]);
  1739.  
  1740.    _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1741.  
  1742.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1743.    _tmp_ret->length = length;
  1744.  
  1745.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1746.  
  1747.    return _tmp_ret;
  1748.  }
  1749.  
  1750.  template<class T>
  1751.  valarray<bool> operator<= (const T& a, const valarray<T>& b)
  1752.  {
  1753.    size_t length= b.size();
  1754.    valarray<bool> tmp_array(length);
  1755.  
  1756.    for(size_t ind=0; ind< length; ind++ )
  1757.     tmp_array[ind] = (a<=b[ind]);
  1758.  
  1759.    _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1760.  
  1761.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1762.    _tmp_ret->length = length;
  1763.  
  1764.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1765.  
  1766.    return _tmp_ret;
  1767.  }
  1768.  
  1769.  template<class T>
  1770.  valarray<bool> operator>= (const T& a, const valarray<T>& b)
  1771.  {
  1772.    size_t length= b.size();
  1773.    valarray<bool> tmp_array(length);
  1774.  
  1775.    for(size_t ind=0; ind< length; ind++ )
  1776.     tmp_array[ind] = (a>=b[ind]);
  1777.  
  1778.    _RW_IMP_SPACE(_RW_temporary<bool>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<bool>);
  1779.  
  1780.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1781.    _tmp_ret->length = length;
  1782.  
  1783.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1784.  
  1785.    return _tmp_ret;
  1786.  }
  1787.  
  1788.  
  1789.  #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  1790.  // min and max functions
  1791.  
  1792.    template <class T>
  1793.    T valarray<T>::min()const
  1794.    {
  1795.      T tmp;
  1796.       if ( size() > 0 )
  1797.      {
  1798.        tmp = memory_array[0];
  1799.        for(size_t ind=1; ind< size(); ind++)
  1800.         if ( memory_array[ind] < tmp )
  1801.          tmp= memory_array[ind];
  1802.      }
  1803.  
  1804.       return tmp;
  1805.    }
  1806.  
  1807.    template <class T>
  1808.    T valarray<T>::max()const
  1809.    {
  1810.     T tmp;
  1811.      if ( size() > 0 )
  1812.      {
  1813.        tmp = memory_array[0];
  1814.        for(size_t ind=1; ind< size(); ind++)
  1815.         if ( memory_array[ind] > tmp )
  1816.          tmp= memory_array[ind];
  1817.      }
  1818.  
  1819.       return tmp;
  1820.    }
  1821. #else
  1822.  
  1823.  
  1824.    template <class T>
  1825.    T min(const valarray<T>& ar)
  1826.    {
  1827.      T tmp;
  1828.       if ( ar.size() > 0 )
  1829.      {
  1830.        tmp = ar[0];
  1831.        for(size_t ind=1; ind< ar.size(); ind++)
  1832.         if ( ar[ind] < tmp )
  1833.          tmp= ar[ind];
  1834.      }
  1835.  
  1836.       return tmp;
  1837.    }
  1838.  
  1839.    template <class T>
  1840.    T max(const valarray<T>& ar)
  1841.    {
  1842.     T tmp;
  1843.      if ( ar.size() > 0 )
  1844.      {
  1845.        tmp = ar[0];
  1846.        for(size_t ind=1; ind< ar.size(); ind++)
  1847.         if ( ar[ind] > tmp )
  1848.          tmp= ar[ind];
  1849.      }
  1850.  
  1851.       return tmp;
  1852.    }
  1853. #endif   
  1854.  
  1855.  
  1856. // transcendentals
  1857.  
  1858.  
  1859.  template<class T>
  1860.  valarray<T> abs(const valarray<T>& a)
  1861.  {
  1862.    valarray<T> tmp_array(a.size());
  1863.  
  1864.    for(size_t ind=0; ind< a.size(); ind++ )
  1865.     tmp_array[ind] = abs(a[ind]);             
  1866.  
  1867.    // note: abs need to be overloaded for 
  1868.    // float, long double and long see (17.3.1.1)
  1869.  
  1870.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1871.  
  1872.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1873.    _tmp_ret->length = a.size();
  1874.  
  1875.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1876.  
  1877.    return _tmp_ret;
  1878.  }
  1879.  
  1880.  template<class T>
  1881.  valarray<T> acos(const valarray<T>& a)
  1882.  {
  1883.    valarray<T> tmp_array(a.size());
  1884.  
  1885.    for(size_t ind=0; ind< a.size(); ind++ )
  1886.     tmp_array[ind] = acos(a[ind]);             
  1887.  
  1888.    // note: acos need to be overloaded for 
  1889.    // float, long double see (17.3.1.1)
  1890.  
  1891.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1892.  
  1893.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1894.    _tmp_ret->length = a.size();
  1895.  
  1896.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1897.  
  1898.    return _tmp_ret;
  1899.  }
  1900.  
  1901.  template<class T>
  1902.  valarray<T> asin(const valarray<T>& a)
  1903.  {
  1904.    valarray<T> tmp_array(a.size());
  1905.  
  1906.    for(size_t ind=0; ind< a.size(); ind++ )
  1907.     tmp_array[ind] = asin(a[ind]);             
  1908.  
  1909.    // note: asin need to be overloaded for 
  1910.    // float, long double see (17.3.1.1)
  1911.  
  1912.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1913.  
  1914.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1915.    _tmp_ret->length = a.size();
  1916.  
  1917.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1918.  
  1919.    return _tmp_ret;
  1920.  }
  1921.  
  1922.  template<class T>
  1923.  valarray<T> atan(const valarray<T>& a)
  1924.  {
  1925.    valarray<T> tmp_array(a.size());
  1926.  
  1927.    for(size_t ind=0; ind< a.size(); ind++ )
  1928.     tmp_array[ind] = atan(a[ind]);             
  1929.  
  1930.    // note: atan need to be overloaded for 
  1931.    // float, long double see (17.3.1.1)
  1932.  
  1933.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1934.  
  1935.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1936.    _tmp_ret->length = a.size();
  1937.  
  1938.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1939.  
  1940.    return _tmp_ret;
  1941.  }
  1942.  
  1943.  template<class T>
  1944.  valarray<T> cos(const valarray<T>& a)
  1945.  {
  1946.    valarray<T> tmp_array(a.size());
  1947.  
  1948.    for(size_t ind=0; ind< a.size(); ind++ )
  1949.        tmp_array[ind] = cos(a[ind]);
  1950.  
  1951.    // note: cos need to be overloaded for 
  1952.    // float, long double see (17.3.1.1)
  1953.  
  1954.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1955.  
  1956.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1957.    _tmp_ret->length = a.size();
  1958.  
  1959.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1960.  
  1961.    return _tmp_ret;
  1962.  }
  1963.  
  1964.  template<class T>
  1965.  valarray<T> cosh(const valarray<T>& a)
  1966.  {
  1967.    valarray<T> tmp_array(a.size());
  1968.  
  1969.    for(size_t ind=0; ind< a.size(); ind++ )
  1970.     tmp_array[ind] = cosh(a[ind]);             
  1971.  
  1972.    // note: cosh need to be overloaded for 
  1973.    // float, long double see (17.3.1.1)
  1974.  
  1975.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1976.  
  1977.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1978.    _tmp_ret->length = a.size();
  1979.  
  1980.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  1981.  
  1982.    return _tmp_ret;
  1983.  }
  1984.  
  1985.  template<class T>
  1986.  valarray<T> exp(const valarray<T>& a)
  1987.  {
  1988.    valarray<T> tmp_array(a.size());
  1989.  
  1990.    for(size_t ind=0; ind< a.size(); ind++ )
  1991.     tmp_array[ind] = exp(a[ind]);             
  1992.  
  1993.    // note: exp need to be overloaded for 
  1994.    // float, long double see (17.3.1.1)
  1995.  
  1996.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  1997.  
  1998.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  1999.    _tmp_ret->length = a.size();
  2000.  
  2001.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  2002.  
  2003.    return _tmp_ret;
  2004.  }
  2005.  
  2006.  template<class T>
  2007.  valarray<T> log(const valarray<T>& a)
  2008.  {
  2009.    valarray<T> tmp_array(a.size());
  2010.  
  2011.    for(size_t ind=0; ind< a.size(); ind++ )
  2012.     tmp_array[ind] = log(a[ind]);             
  2013.  
  2014.    // note: log need to be overloaded for 
  2015.    // float, long double see (17.3.1.1)
  2016.  
  2017.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  2018.  
  2019.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  2020.    _tmp_ret->length = a.size();
  2021.  
  2022.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  2023.  
  2024.    return _tmp_ret;
  2025.  }
  2026.  
  2027.  template<class T>
  2028.  valarray<T> log10(const valarray<T>& a)
  2029.  {
  2030.    valarray<T> tmp_array(a.size());
  2031.  
  2032.    for(size_t ind=0; ind< a.size(); ind++ )
  2033.     tmp_array[ind] = log10(a[ind]);             
  2034.  
  2035.    // note: log10 need to be overloaded for 
  2036.    // float, long double see (17.3.1.1)
  2037.  
  2038.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  2039.  
  2040.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  2041.    _tmp_ret->length = a.size();
  2042.  
  2043.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  2044.  
  2045.    return _tmp_ret;
  2046.  }
  2047.  
  2048.  template<class T>
  2049.  valarray<T> sinh(const valarray<T>& a)
  2050.  {
  2051.    valarray<T> tmp_array(a.size());
  2052.  
  2053.    for(size_t ind=0; ind< a.size(); ind++ )
  2054.     tmp_array[ind] = sinh(a[ind]);             
  2055.  
  2056.    // note: sinh need to be overloaded for 
  2057.    // float, long double see (17.3.1.1)
  2058.  
  2059.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  2060.  
  2061.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  2062.    _tmp_ret->length = a.size();
  2063.  
  2064.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  2065.  
  2066.    return _tmp_ret;
  2067.  }
  2068.  
  2069.  template<class T>
  2070.  valarray<T> sin(const valarray<T>& a)
  2071.  {
  2072.    valarray<T> tmp_array(a.size());
  2073.  
  2074.    for(size_t ind=0; ind< a.size(); ind++ )
  2075.     tmp_array[ind] = sin(a[ind]);             
  2076.  
  2077.    // note: sin need to be overloaded for 
  2078.    // float, long double see (17.3.1.1)
  2079.  
  2080.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  2081.  
  2082.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  2083.    _tmp_ret->length = a.size();
  2084.  
  2085.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  2086.  
  2087.    return _tmp_ret;
  2088.  }
  2089.  
  2090.  template<class T>
  2091.  valarray<T> sqrt(const valarray<T>& a)
  2092.  {
  2093.    valarray<T> tmp_array(a.size());
  2094.  
  2095.    for(size_t ind=0; ind< a.size(); ind++ )
  2096.     tmp_array[ind] = sqrt(a[ind]);             
  2097.  
  2098.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  2099.  
  2100.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  2101.    _tmp_ret->length = a.size();
  2102.  
  2103.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  2104.  
  2105.    return _tmp_ret;
  2106.  }
  2107.  
  2108.  template<class T>
  2109.  valarray<T> tan(const valarray<T>& a)
  2110.  {
  2111.    valarray<T> tmp_array(a.size());
  2112.  
  2113.    for(size_t ind=0; ind< a.size(); ind++ )
  2114.     tmp_array[ind] = tan(a[ind]);             
  2115.  
  2116.    // note: tan need to be overloaded for 
  2117.    // float, long double see (17.3.1.1)
  2118.  
  2119.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  2120.  
  2121.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  2122.    _tmp_ret->length = a.size();
  2123.  
  2124.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  2125.  
  2126.    return _tmp_ret;
  2127.  }
  2128.  
  2129.  
  2130.  template<class T>
  2131.  valarray<T> tanh(const valarray<T>& a)
  2132.  {
  2133.    valarray<T> tmp_array(a.size());
  2134.  
  2135.    for(size_t ind=0; ind< a.size(); ind++ )
  2136.     tmp_array[ind] = tanh(a[ind]);             
  2137.  
  2138.    // note: tanh need to be overloaded for 
  2139.    // float, long double see (17.3.1.1)
  2140.  
  2141.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  2142.  
  2143.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  2144.    _tmp_ret->length = a.size();
  2145.  
  2146.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  2147.  
  2148.    return _tmp_ret;
  2149.  }
  2150.  
  2151.  template<class T>
  2152.  valarray<T> atan2(const valarray<T>& a, const valarray<T>& b)
  2153.  {
  2154.    size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  2155.    valarray<T> tmp_array(length);
  2156.  
  2157.    for(size_t ind=0; ind< length; ind++ )
  2158.     tmp_array[ind] = atan2(a[ind],b[ind]);             
  2159.  
  2160.    // note: atan2 need to be overloaded for 
  2161.    // float, long double see (17.3.1.1)
  2162.  
  2163.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  2164.  
  2165.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  2166.    _tmp_ret->length = length;
  2167.  
  2168.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  2169.  
  2170.    return _tmp_ret;
  2171.  }
  2172.  
  2173.  template<class T>
  2174.  valarray<T> atan2(const valarray<T>& a, const T& b)
  2175.  {
  2176.    size_t length= a.size();
  2177.    valarray<T> tmp_array(length);
  2178.  
  2179.    for(size_t ind=0; ind< length; ind++ )
  2180.     tmp_array[ind] = atan2(a[ind],b);             
  2181.  
  2182.    // note: atan2 need to be overloaded for 
  2183.    // float, long double see (17.3.1.1)
  2184.  
  2185.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  2186.  
  2187.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  2188.    _tmp_ret->length = length;
  2189.  
  2190.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  2191.  
  2192.    return _tmp_ret;
  2193.  }
  2194.  
  2195.  template<class T>
  2196.  valarray<T> atan2(const T& a, const valarray<T>& b)
  2197.  {
  2198.    size_t length= b.size();
  2199.    valarray<T> tmp_array(length);
  2200.  
  2201.    for(size_t ind=0; ind< length; ind++ )
  2202.     tmp_array[ind] = atan2(a,b[ind]);             
  2203.  
  2204.    // note: atan2 need to be overloaded for 
  2205.    // float, long double see (17.3.1.1)
  2206.  
  2207.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  2208.  
  2209.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  2210.    _tmp_ret->length = length;
  2211.  
  2212.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  2213.  
  2214.    return _tmp_ret;
  2215.  }
  2216.  
  2217.  template<class T>
  2218.  valarray<T> pow(const valarray<T>& a, const valarray<T>& b)
  2219.  {
  2220.    size_t length= ( a.size() > b.size() ) ? b.size() : a.size();
  2221.    valarray<T> tmp_array(length);
  2222.  
  2223.    for(size_t ind=0; ind< length; ind++ )
  2224.     tmp_array[ind] = pow(a[ind],b[ind]);             
  2225.  
  2226.    // note: pow need to be overloaded for 
  2227.    // float, long double see (17.3.1.1)
  2228.  
  2229.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  2230.  
  2231.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  2232.    _tmp_ret->length = length;
  2233.  
  2234.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  2235.  
  2236.    return _tmp_ret;
  2237.  }
  2238.  
  2239.  template<class T>
  2240.  valarray<T> pow(const valarray<T>& a, const T& b)
  2241.  {
  2242.    size_t length= a.size();
  2243.    valarray<T> tmp_array(length);
  2244.  
  2245.    for(size_t ind=0; ind< length; ind++ )
  2246.     tmp_array[ind] = pow(a[ind],b);             
  2247.  
  2248.    // note: pow need to be overloaded for 
  2249.    // float, long double see (17.3.1.1)
  2250.  
  2251.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  2252.  
  2253.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  2254.    _tmp_ret->length = length;
  2255.  
  2256.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  2257.  
  2258.    return _tmp_ret;
  2259.  }
  2260.  
  2261.  template<class T>
  2262.  valarray<T> pow(const T& a, const valarray<T>& b)
  2263.  {
  2264.    size_t length= b.size();
  2265.    valarray<T> tmp_array(length);
  2266.  
  2267.    for(size_t ind=0; ind< length; ind++ )
  2268.        tmp_array[ind] = pow(a,b[ind]);             
  2269.  
  2270.    // note: pow need to be overloaded for 
  2271.    // float, long double see (17.3.1.1)
  2272.  
  2273.    _RW_IMP_SPACE(_RW_temporary<T>)* _tmp_ret = new _RW_IMP_SPACE(_RW_temporary<T>);
  2274.  
  2275.    _tmp_ret->store_adr = tmp_array._RW_get_memory_array()._RW_get_storage();
  2276.    _tmp_ret->length = length;
  2277.  
  2278.    tmp_array._RW_get_memory_array_adr()->_RW_invalidate();
  2279.  
  2280.    return _tmp_ret;
  2281.  }
  2282.  
  2283.  
  2284. /*****************************************************************
  2285. *                                                                *
  2286. *                 SLICE_ARRAY MEMBER FUNCTIONS                   *
  2287. *                                                                *
  2288. ******************************************************************/
  2289.  
  2290. // slice_array inline member functions
  2291.  
  2292.    template <class T>
  2293.    void slice_array<T>::operator= (const valarray<T>& array) const
  2294.    { 
  2295.       size_t ind = slice_.start();
  2296.       size_t cpt = 0; 
  2297.  
  2298.       while( cpt < slice_.length() )
  2299.       {
  2300.         if ( (cpt<array.size()) && (ind<ref_mem_array->_get_length()) )
  2301.         (*ref_mem_array)[ind] = array[cpt];
  2302.         ind+= slice_.stride();
  2303.         cpt++;
  2304.       }
  2305.    }
  2306.  
  2307.    template <class T>
  2308.    void slice_array<T>::operator= (const T& value) const
  2309.    { 
  2310.       size_t ind = slice_.start();
  2311.       size_t cpt = 0; 
  2312.  
  2313.       while( cpt < slice_.length() )
  2314.       {
  2315.         if ( ind<ref_mem_array->_get_length() )
  2316.         (*ref_mem_array)[ind] = value;
  2317.         ind+= slice_.stride();
  2318.         cpt++;
  2319.       }
  2320.    }
  2321.  
  2322.  
  2323. // computed assignment
  2324.  
  2325.    template <class T>
  2326.    void slice_array<T>::operator*= (const valarray<T>& array) const
  2327.    { 
  2328.       size_t ind = slice_.start();
  2329.       size_t cpt = 0; 
  2330.  
  2331.       while( cpt < slice_.length() )
  2332.       {
  2333.         if ( (cpt<array.size()) && (ind<ref_mem_array->_get_length()) )
  2334.         (*ref_mem_array)[ind] *= array[cpt];
  2335.         ind+= slice_.stride();
  2336.         cpt++;
  2337.       }
  2338.    }
  2339.  
  2340.    template <class T>
  2341.    void slice_array<T>::operator/= (const valarray<T>& array) const
  2342.    { 
  2343.       size_t ind = slice_.start();
  2344.       size_t cpt = 0; 
  2345.  
  2346.       while( cpt < slice_.length() )
  2347.       {
  2348.         if ( (cpt<array.size()) && (ind<ref_mem_array->_get_length()) )
  2349.         (*ref_mem_array)[ind] /= array[cpt];
  2350.         ind+= slice_.stride();
  2351.         cpt++;
  2352.       }
  2353.    }
  2354.  
  2355.    template <class T>
  2356.    void slice_array<T>::operator+= (const valarray<T>& array) const
  2357.    {
  2358.       size_t ind = slice_.start();
  2359.       size_t cpt = 0;
  2360.  
  2361.       while( cpt < slice_.length() )
  2362.       {
  2363.         if ( (cpt<array.size()) && (ind<ref_mem_array->_get_length()) )
  2364.         (*ref_mem_array)[ind] += array[cpt];
  2365.         ind+= slice_.stride();
  2366.         cpt++;
  2367.       }
  2368.    }
  2369.  
  2370.    template <class T>
  2371.    void slice_array<T>::operator-= (const valarray<T>& array) const
  2372.    {
  2373.       size_t ind = slice_.start();
  2374.       size_t cpt = 0;
  2375.  
  2376.       while( cpt < slice_.length() )
  2377.       {
  2378.         if ( (cpt<array.size()) && (ind<ref_mem_array->_get_length()) )
  2379.         (*ref_mem_array)[ind] -= array[cpt];
  2380.         ind+= slice_.stride();
  2381.         cpt++;
  2382.       }
  2383.    }
  2384.  
  2385.  #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  2386.    template <class T>
  2387.    void slice_array<T>::operator%= (const valarray<T>& array) const
  2388.    {
  2389.       size_t ind = slice_.start();
  2390.       size_t cpt = 0;
  2391.  
  2392.       while( cpt < slice_.length() )
  2393.       {
  2394.         if ( (cpt<array.size()) && (ind<ref_mem_array->_get_length()) )
  2395.         (*ref_mem_array)[ind] %= array[cpt];
  2396.         ind+= slice_.stride();
  2397.         cpt++;
  2398.       }
  2399.    }
  2400.  
  2401.    template <class T>
  2402.    void slice_array<T>::operator^= (const valarray<T>& array) const
  2403.    {
  2404.       size_t ind = slice_.start();
  2405.       size_t cpt = 0; 
  2406.  
  2407.       while( cpt < slice_.length() )
  2408.       {
  2409.         if ( (cpt<array.size()) && (ind<ref_mem_array->_get_length()) )
  2410.         (*ref_mem_array)[ind] ^= array[cpt];
  2411.         ind+= slice_.stride();
  2412.         cpt++;
  2413.       }
  2414.    }
  2415.  
  2416.    template <class T>
  2417.    void slice_array<T>::operator&= (const valarray<T>& array) const
  2418.    { 
  2419.       size_t ind = slice_.start();
  2420.       size_t cpt = 0; 
  2421.  
  2422.       while( cpt < slice_.length() )
  2423.       {
  2424.         if ( (cpt<array.size()) && (ind<ref_mem_array->_get_length()) )
  2425.         (*ref_mem_array)[ind] &= array[cpt];
  2426.         ind+= slice_.stride();
  2427.         cpt++;
  2428.       }
  2429.    }
  2430.  
  2431.    template <class T>
  2432.    void slice_array<T>::operator|= (const valarray<T>& array) const
  2433.    { 
  2434.       size_t ind = slice_.start();
  2435.       size_t cpt = 0; 
  2436.  
  2437.       while( cpt < slice_.length() )
  2438.       {
  2439.         if ( (cpt<array.size()) && (ind<ref_mem_array->_get_length()) )
  2440.         (*ref_mem_array)[ind] |= array[cpt];
  2441.         ind+= slice_.stride();
  2442.         cpt++;
  2443.       }
  2444.    }
  2445.  
  2446.    template <class T>
  2447.    void slice_array<T>::operator<<= (const valarray<T>& array) const
  2448.    { 
  2449.       size_t ind = slice_.start();
  2450.       size_t cpt = 0; 
  2451.  
  2452.       while( cpt < slice_.length() )
  2453.       {
  2454.         if ( (cpt<array.size()) && (ind<ref_mem_array->_get_length()) )
  2455.         (*ref_mem_array)[ind] <<= array[cpt];
  2456.         ind+= slice_.stride();
  2457.         cpt++;
  2458.       }
  2459.    }
  2460.  
  2461.    template <class T>
  2462.    void slice_array<T>::operator>>= (const valarray<T>& array) const
  2463.    { 
  2464.       size_t ind = slice_.start();
  2465.       size_t cpt = 0; 
  2466.  
  2467.       while( cpt < slice_.length() )
  2468.       {
  2469.         if ( (cpt<array.size()) && (ind<ref_mem_array->_get_length()) )
  2470.         (*ref_mem_array)[ind] >>= array[cpt];
  2471.         ind+= slice_.stride();
  2472.         cpt++;
  2473.       }
  2474.    }
  2475.    #endif
  2476.  
  2477.  
  2478. /*****************************************************************
  2479. *                                                                *
  2480. *                 GSLICE_ARRAY MEMBER FUNCTIONS                  *
  2481. *                                                                *
  2482. ******************************************************************/
  2483.  
  2484.  
  2485. // gslice_array inline member functions
  2486.  
  2487.    template <class T>
  2488.    void gslice_array<T>::operator= (const valarray<T>& array) const
  2489.    {
  2490.       gslice *gsl = (gslice *)&slice_;
  2491.       size_t ind = gsl->next_ind();
  2492.       size_t cpt = 0;
  2493.  
  2494.       while( (!gsl->is_reseted()) && (cpt < array.size()) )
  2495.       {
  2496.         (*ref_mem_array)[ind] = array[cpt];
  2497.     ind= gsl->next_ind();
  2498.     cpt++;
  2499.       }
  2500.    }
  2501.  
  2502.    template <class T>
  2503.    void gslice_array<T>::operator= (const T& value) const
  2504.    { 
  2505.       gslice *gsl = (gslice *)&slice_;
  2506.       size_t ind = gsl->next_ind();
  2507.  
  2508.       while( !gsl->is_reseted() )
  2509.       {
  2510.         (*ref_mem_array)[ind] = value;
  2511.     ind= gsl->next_ind();
  2512.       }
  2513.    }
  2514.  
  2515.  
  2516. // computed assignment
  2517.  
  2518.    template <class T>
  2519.    void gslice_array<T>::operator*= (const valarray<T>& array) const
  2520.    {
  2521.       gslice *gsl = (gslice *)&slice_;
  2522.       size_t ind = gsl->next_ind();
  2523.       size_t cpt = 0;
  2524.  
  2525.       while( (!gsl->is_reseted()) && (cpt < array.size()) )
  2526.       {
  2527.         (*ref_mem_array)[ind] *= array[cpt];
  2528.         ind= gsl->next_ind();
  2529.         cpt++;
  2530.       }
  2531.    }
  2532.  
  2533.    template <class T>
  2534.    void gslice_array<T>::operator/= (const valarray<T>& array) const
  2535.    { 
  2536.       gslice *gsl = (gslice *)&slice_;
  2537.       size_t ind = gsl->next_ind();
  2538.       size_t cpt = 0;
  2539.  
  2540.       while( (!gsl->is_reseted()) && (cpt < array.size()) )
  2541.       {
  2542.         (*ref_mem_array)[ind] /= array[cpt];
  2543.         ind= gsl->next_ind();
  2544.         cpt++;
  2545.       }
  2546.    }
  2547.  
  2548.    template <class T>
  2549.    void gslice_array<T>::operator+= (const valarray<T>& array) const
  2550.    { 
  2551.       gslice *gsl = (gslice *)&slice_;
  2552.       size_t ind = gsl->next_ind();
  2553.       size_t cpt = 0;
  2554.  
  2555.       while( (!gsl->is_reseted()) && (cpt < array.size()) )
  2556.       {
  2557.         (*ref_mem_array)[ind] += array[cpt];
  2558.         ind= gsl->next_ind();
  2559.         cpt++;
  2560.       }
  2561.    }
  2562.  
  2563.    template <class T>
  2564.    void gslice_array<T>::operator-= (const valarray<T>& array) const
  2565.    { 
  2566.       gslice *gsl = (gslice *)&slice_;
  2567.       size_t ind = gsl->next_ind();
  2568.       size_t cpt = 0;
  2569.  
  2570.       while( (!gsl->is_reseted()) && (cpt < array.size()) )
  2571.       {
  2572.         (*ref_mem_array)[ind] -= array[cpt];
  2573.         ind= gsl->next_ind();
  2574.         cpt++;
  2575.       }
  2576.    }
  2577.  
  2578.    #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  2579.    template <class T>
  2580.    void gslice_array<T>::operator%= (const valarray<T>& array) const
  2581.    { 
  2582.       gslice *gsl = (gslice *)&slice_;
  2583.       size_t ind = gsl->next_ind();
  2584.       size_t cpt = 0;
  2585.  
  2586.       while( (!gsl->is_reseted()) && (cpt < array.size()) )
  2587.       {
  2588.         (*ref_mem_array)[ind] %= array[cpt];
  2589.         ind= gsl->next_ind();
  2590.         cpt++;
  2591.       }
  2592.    }
  2593.  
  2594.    template <class T>
  2595.    void gslice_array<T>::operator^= (const valarray<T>& array) const
  2596.    { 
  2597.       gslice *gsl = (gslice *)&slice_;
  2598.       size_t ind = gsl->next_ind();
  2599.       size_t cpt = 0;
  2600.  
  2601.       while( (!gsl->is_reseted()) && (cpt < array.size()) )
  2602.       {
  2603.         (*ref_mem_array)[ind] ^= array[cpt];
  2604.         ind= gsl->next_ind();
  2605.         cpt++;
  2606.       }
  2607.    }
  2608.  
  2609.    template <class T>
  2610.    void gslice_array<T>::operator&= (const valarray<T>& array) const
  2611.    { 
  2612.       gslice *gsl = (gslice *)&slice_;
  2613.       size_t ind = gsl->next_ind();
  2614.       size_t cpt = 0;
  2615.  
  2616.       while( (!gsl->is_reseted()) && (cpt < array.size()) )
  2617.       {
  2618.         (*ref_mem_array)[ind] &= array[cpt];
  2619.         ind= gsl->next_ind();
  2620.         cpt++;
  2621.       }
  2622.    }
  2623.  
  2624.    template <class T>
  2625.    void gslice_array<T>::operator|= (const valarray<T>& array) const
  2626.    { 
  2627.       gslice *gsl = (gslice *)&slice_;
  2628.       size_t ind = gsl->next_ind();
  2629.       size_t cpt = 0;
  2630.  
  2631.       while( (!gsl->is_reseted()) && (cpt < array.size()) )
  2632.       {
  2633.         (*ref_mem_array)[ind] |= array[cpt];
  2634.         ind= gsl->next_ind();
  2635.         cpt++;
  2636.       }
  2637.    }
  2638.  
  2639.    template <class T>
  2640.    void gslice_array<T>::operator<<= (const valarray<T>& array) const
  2641.    { 
  2642.       gslice *gsl = (gslice *)&slice_;
  2643.       size_t ind = gsl->next_ind();
  2644.       size_t cpt = 0;
  2645.  
  2646.       while( (!gsl->is_reseted()) && (cpt < array.size()) )
  2647.       {
  2648.         (*ref_mem_array)[ind] <<= array[cpt];
  2649.         ind= gsl->next_ind();
  2650.         cpt++;
  2651.       }
  2652.    }
  2653.  
  2654.    template <class T>
  2655.    void gslice_array<T>::operator>>= (const valarray<T>& array) const
  2656.    { 
  2657.       gslice *gsl = (gslice *)&slice_;
  2658.       size_t ind = gsl->next_ind();
  2659.       size_t cpt = 0;
  2660.  
  2661.       while( (!gsl->is_reseted()) && (cpt < array.size()) )
  2662.       {
  2663.         (*ref_mem_array)[ind] >>= array[cpt];
  2664.         ind= gsl->next_ind();
  2665.         cpt++;
  2666.       }
  2667.    }
  2668.    #endif
  2669.  
  2670.  
  2671. /*****************************************************************
  2672. *                                                                *
  2673. *                 MASK_ARRAY MEMBER FUNCTIONS                    *
  2674. *                                                                *
  2675. ******************************************************************/
  2676.  
  2677. // mask_array inline member functions
  2678.  
  2679.    template <class T>
  2680.    void mask_array<T>::operator= (const valarray<T>& ar) const
  2681.    {  
  2682.       size_t cpt = 0; 
  2683.  
  2684.       for(size_t iter=0; iter < array.size(); iter++ )
  2685.        if ( array[iter] ) 
  2686.         (*ref_mem_array)[iter]= ar[cpt++];
  2687.     }
  2688.  
  2689.    template <class T>
  2690.    void mask_array<T>::operator= (const T& value) const
  2691.    {
  2692.       for(size_t iter=0; iter < array.size(); iter++ )
  2693.        if ( array[iter] )
  2694.         (*ref_mem_array)[iter]= value;
  2695.    }
  2696.  
  2697.  
  2698.    template <class T>
  2699.    void mask_array<T>::operator*= (const valarray<T>& ar) const
  2700.    {  
  2701.       size_t cpt = 0; 
  2702.  
  2703.       for(size_t iter=0; iter < array.size(); iter++ )
  2704.        if ( array[iter] ) 
  2705.         (*ref_mem_array)[iter] *= ar[cpt++];
  2706.     }
  2707.  
  2708.    template <class T>
  2709.    void mask_array<T>::operator/= (const valarray<T>& ar) const
  2710.    {  
  2711.       size_t cpt = 0; 
  2712.  
  2713.       for(size_t iter=0; iter < array.size(); iter++ )
  2714.        if ( array[iter] ) 
  2715.         (*ref_mem_array)[iter]/= ar[cpt++];
  2716.     }
  2717.  
  2718.    template <class T>
  2719.    void mask_array<T>::operator+= (const valarray<T>& ar) const
  2720.    {  
  2721.       size_t cpt = 0; 
  2722.  
  2723.       for(size_t iter=0; iter < array.size(); iter++ )
  2724.        if ( array[iter] )
  2725.         (*ref_mem_array)[iter]+= ar[cpt++];
  2726.     }
  2727.  
  2728.    template <class T>
  2729.    void mask_array<T>::operator-= (const valarray<T>& ar) const
  2730.    {  
  2731.       size_t cpt = 0;
  2732.  
  2733.       for(size_t iter=0; iter < array.size(); iter++ )
  2734.        if ( array[iter] )
  2735.         (*ref_mem_array)[iter]-= ar[cpt++];
  2736.     }
  2737.  
  2738.  
  2739.    #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  2740.  
  2741.    template <class T>
  2742.    void mask_array<T>::operator%= (const valarray<T>& ar) const
  2743.    {
  2744.       size_t cpt = 0;
  2745.  
  2746.       for(size_t iter=0; iter < array.size(); iter++ )
  2747.        if ( array[iter] )
  2748.         (*ref_mem_array)[iter]%= ar[cpt++];
  2749.     }
  2750.  
  2751.    template <class T>
  2752.    void mask_array<T>::operator^= (const valarray<T>& ar) const
  2753.    {
  2754.       size_t cpt = 0;
  2755.  
  2756.       for(size_t iter=0; iter < array.size(); iter++ )
  2757.        if ( array[iter] )
  2758.         (*ref_mem_array)[iter]^= ar[cpt++];
  2759.     }
  2760.  
  2761.    template <class T>
  2762.    void mask_array<T>::operator&= (const valarray<T>& ar) const
  2763.    {
  2764.       size_t cpt = 0;
  2765.  
  2766.       for(size_t iter=0; iter < array.size(); iter++ )
  2767.        if ( array[iter] )
  2768.         (*ref_mem_array)[iter]&= ar[cpt++];
  2769.     }
  2770.  
  2771.    template <class T>
  2772.    void mask_array<T>::operator|= (const valarray<T>& ar) const
  2773.    {
  2774.       size_t cpt = 0;
  2775.  
  2776.       for(size_t iter=0; iter < array.size(); iter++ )
  2777.        if ( array[iter] )
  2778.         (*ref_mem_array)[iter]|= ar[cpt++];
  2779.     }
  2780.  
  2781.    template <class T>
  2782.    void mask_array<T>::operator<<= (const valarray<T>& ar) const
  2783.    {
  2784.       size_t cpt = 0;
  2785.  
  2786.       for(size_t iter=0; iter < array.size(); iter++ )
  2787.        if ( array[iter] )
  2788.         (*ref_mem_array)[iter]<<= ar[cpt++];
  2789.     }
  2790.  
  2791.    template <class T>
  2792.    void mask_array<T>::operator>>= (const valarray<T>& ar) const
  2793.    {
  2794.       size_t cpt = 0;
  2795.  
  2796.       for(size_t iter=0; iter < array.size(); iter++ )
  2797.        if ( array[iter] )
  2798.         (*ref_mem_array)[iter]>>= ar[cpt++];
  2799.     }
  2800.    #endif
  2801.  
  2802. /*****************************************************************
  2803. *                                                                *
  2804. *                 INDIRECT_ARRAY MEMBER FUNCTIONS                *
  2805. *                                                                *
  2806. ******************************************************************/
  2807.  
  2808. // indirect_array inline member functions
  2809.  
  2810.    template <class T>
  2811.    void indirect_array<T>::operator= (const valarray<T>& ar) const
  2812.    {
  2813.       size_t cpt=0;
  2814.  
  2815.       for(size_t iter=0; iter < array.size(); iter++ )
  2816.        (*ref_mem_array)[array[iter]] = ar[cpt++];
  2817.    }
  2818.  
  2819.    template <class T>
  2820.    void indirect_array<T>::operator= (const T& value) const
  2821.    {
  2822.       for(size_t iter=0; iter < array.size(); iter++ )
  2823.        (*ref_mem_array)[array[iter]] = value;
  2824.    }
  2825.  
  2826.  
  2827.    template <class T>
  2828.    void indirect_array<T>::operator*= (const valarray<T>& ar) const
  2829.    {
  2830.       size_t cpt=0;
  2831.  
  2832.       for(size_t iter=0; iter < array.size(); iter++ )
  2833.        (*ref_mem_array)[array[iter]] *= ar[cpt++];
  2834.    }
  2835.  
  2836.    template <class T>
  2837.    void indirect_array<T>::operator/= (const valarray<T>& ar) const
  2838.    {
  2839.       size_t cpt=0;
  2840.  
  2841.       for(size_t iter=0; iter < array.size(); iter++ )
  2842.        (*ref_mem_array)[array[iter]] /= ar[cpt++];
  2843.    }
  2844.  
  2845.    template <class T>
  2846.    void indirect_array<T>::operator+= (const valarray<T>& ar) const
  2847.    {
  2848.       size_t cpt=0;
  2849.  
  2850.       for(size_t iter=0; iter < array.size(); iter++ )
  2851.        (*ref_mem_array)[array[iter]] += ar[cpt++];
  2852.    }
  2853.  
  2854.    template <class T>
  2855.    void indirect_array<T>::operator-= (const valarray<T>& ar) const
  2856.    {
  2857.       size_t cpt=0;
  2858.  
  2859.       for(size_t iter=0; iter < array.size(); iter++ )
  2860.        (*ref_mem_array)[array[iter]] -= ar[cpt++];
  2861.    }
  2862.  
  2863.  
  2864.    #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  2865.  
  2866.    template <class T>
  2867.    void indirect_array<T>::operator%= (const valarray<T>& ar) const
  2868.    {
  2869.       size_t cpt=0;
  2870.  
  2871.       for(size_t iter=0; iter < array.size(); iter++ )
  2872.        (*ref_mem_array)[array[iter]] %= ar[cpt++];
  2873.    }
  2874.  
  2875.    template <class T>
  2876.    void indirect_array<T>::operator^= (const valarray<T>& ar) const
  2877.    {
  2878.       size_t cpt=0;
  2879.  
  2880.       for(size_t iter=0; iter < array.size(); iter++ )
  2881.        (*ref_mem_array)[array[iter]] ^= ar[cpt++];
  2882.    }
  2883.  
  2884.    template <class T>
  2885.    void indirect_array<T>::operator&= (const valarray<T>& ar) const
  2886.    { 
  2887.       size_t cpt=0;
  2888.  
  2889.       for(size_t iter=0; iter < array.size(); iter++ )
  2890.        (*ref_mem_array)[array[iter]] &= ar[cpt++];
  2891.    }
  2892.  
  2893.    template <class T>
  2894.    void indirect_array<T>::operator|= (const valarray<T>& ar) const
  2895.    { 
  2896.       size_t cpt=0;
  2897.  
  2898.       for(size_t iter=0; iter < array.size(); iter++ )
  2899.        (*ref_mem_array)[array[iter]] |= ar[cpt++];
  2900.    }
  2901.  
  2902.  
  2903.    template <class T>
  2904.    void indirect_array<T>::operator<<= (const valarray<T>& ar) const
  2905.    { 
  2906.       size_t cpt=0;
  2907.  
  2908.       for(size_t iter=0; iter < array.size(); iter++ )
  2909.        (*ref_mem_array)[array[iter]] <<= ar[cpt++];
  2910.    }
  2911.  
  2912.  
  2913.    template <class T>
  2914.    void indirect_array<T>::operator>>= (const valarray<T>& ar) const
  2915.    { 
  2916.       size_t cpt=0;
  2917.  
  2918.       for(size_t iter=0; iter < array.size(); iter++ )
  2919.        (*ref_mem_array)[array[iter]] >>= ar[cpt++];
  2920.    }
  2921.    #endif
  2922.  
  2923.  
  2924. #ifndef _RWSTD_NO_NAMESPACE
  2925. }
  2926. #endif
  2927.  
  2928. #pragma option pop
  2929. #endif /* __VALARRAY_CC */
  2930.